SpringBoot在内部通过集成hibernate-validation,可以直接使用。项目中我们需要经常的去判断前端传递到后端的数据是否正确，这个时候需要些大量的if语句，代码相对比较中。这个时候validation就发挥了很大的作用。
 

Bean Validation 中内置的 验证规则：

Hibernate Validator 验证规则：                              

  注意区分:

1
此处使用spring内置的Validate：
2
 
3
pom：

1
 <dependency>
2
      <groupId>org.springframework.boot</groupId>
3
      <artifactId>spring-boot-starter-web</artifactId>
4
 </dependency>

其内置了：

1
<dependency>
2
    <groupId>org.hibernate</groupId>
3
    <artifactId>hibernate-validator</artifactId>
4
</dependency>
5
<dependency>
6
    <groupId>com.fasterxml.jackson.core</groupId>
7
    <artifactId>jackson-databind</artifactId>
8
</dependency>

1
使用：
2
1.请求方法中的请求参数上直接添加验证规则 如：@NotNull ，这里需要注意的是在该类上面需要添加@Validated。千万不要忘记，不然不会生效。

1
/**
2
 *
3
 *@NotBlank @NotNull 如果在请求的方法上 直接使用 需要在该类上添加
4
 * @Validated 注解 否则 该验证注解不生效
5
 *
6
 * 如果在请求对象中的属性上使用校验 注解 需要在方法请求参数中 该对象之前使用 @Validated 对象 对象名
7
 *
8
 */
9
@RestController
10
//非对象接收的参数 在类上需要添加该注解
11
@Validated
12
public class UserController {
13
    private static final Logger log = LoggerFactory.getLogger(UserController.class);
14
    @RequestMapping("/getUserInfo")
15
    public RestResultWrapper getUserInfo(@NotBlank(message = "地址不能为空！") @RequestParam(name = "address") String Address){
16
        User user=new User();
17
        user.setAddress("ssssssss");
18
        user.setAge(20);
19
        user.setBianhao(58588);
20
        user.setName("天狗食日");
21
        return new RestResultWrapper(user,0,"成功");
22
    }
23
 
24
}

1
2.嵌套使用验证规则。如在实体类中的属性上使用验证规则。并且此时需要在请求实体类旁边添加@Validated
2
 

1
@Data
2
public class UserRequest {
3
 
4
    @NotNull(message = "姓名不能为空")
5
    private String name;
6
 
7
    //{user.name.notblank} 从 ValidationMessages.properties 获取到的
8
    @NotNull(message = "{user.name.notblank}")
9
    @Range(max = 150, min = 1, message = "年龄范围应该在1-150内。")
10
    private Integer age;
11
 
12
    @NotNull(message = "编号不能为空")
13
    private Integer bianhao;
14
 
15
    @NotNull(message = "地址不能为空")
16
    private String address;
17
 
18
}

1
@RestController
2
public class ValidateController {
3
 
4
 
5
    /**
6
     * 结果是空的
7
     * @param userRequest
8
     * @return
9
     */
10
    @RequestMapping("/getUserOne")
11
    public RestResultWrapper getUserOne(@Validated UserRequest userRequest){
12
        User user=new User();
13
        user.setAddress("ssssssss");
14
        user.setAge(20);
15
        user.setBianhao(58588);
16
        user.setName("天狗食日");
17
        return new RestResultWrapper(user,0,"成功");
18
    }
19
}

1
         
2
异常处理：
3
验证不通过的时候一般使用全局异常进行处理。设计到三个类：

ConstraintViolationException（方法参数校验异常）如实体类中的@Size注解配置和数据库中该字段的长度不统一等问题

MethodArgumentNotValidException（Bean 校验异常）

BindException （参数绑定异常）

请求时候不加任何参数：BindException

1
package com.springboot.validate.springbootvalidateexception.exception;
2
 
3
 
4
import com.springboot.validate.springbootvalidateexception.constant.RestResultWrapper;
5
import org.slf4j.Logger;
6
import org.slf4j.LoggerFactory;
7
import org.springframework.http.HttpStatus;
8
import org.springframework.util.CollectionUtils;
9
import org.springframework.validation.BindException;
10
import org.springframework.validation.FieldError;
11
import org.springframework.validation.ObjectError;
12
import org.springframework.web.HttpRequestMethodNotSupportedException;
13
import org.springframework.web.bind.MethodArgumentNotValidException;
14
import org.springframework.web.bind.MissingServletRequestParameterException;
15
import org.springframework.web.bind.annotation.ExceptionHandler;
16
import org.springframework.web.bind.annotation.ResponseBody;
17
import org.springframework.web.bind.annotation.RestControllerAdvice;
18
 
19
import javax.servlet.http.HttpServletRequest;
20
import javax.validation.ConstraintViolationException;
21
import java.text.SimpleDateFormat;
22
import java.util.*;
23
import java.util.stream.Collectors;
24
 
25
/**
26
 * 全局异常处理 无法处理filter抛出的异常
27
 */
28
@RestControllerAdvice
29
public class OnlineGlobalException {
30
 
31
    private static Logger logger = LoggerFactory.getLogger(OnlineGlobalException.class);
32
 
33
    /**
34
     * 方法参数校验异常 Validate
35
     * @param request
36
     * @param ex
37
     * @return
38
     */
39
    @ExceptionHandler(ConstraintViolationException.class)
40
    @ResponseBody
41
    public RestResultWrapper handleValidationException(HttpServletRequest request, ConstraintViolationException ex) {
42
        logger.error("异常:" + request.getRequestURI(), ex);
43
        String collect = ex.getConstraintViolations().stream().filter(Objects::nonNull)
44
                .map(cv -> cv == null ? "null" : cv.getPropertyPath() + ": " + cv.getMessage())
45
                .collect(Collectors.joining(", "));
46
        RestResultWrapper<String> restResultWrapper = new RestResultWrapper();
47
        logger.info("请求参数异常",collect);
48
        restResultWrapper.setCode(HttpStatus.BAD_REQUEST.value());
49
        restResultWrapper.setMessage(ex.getMessage());
50
        return restResultWrapper;
51
    }
52
 
53
    /**
54
     * Bean 校验异常 Validate
55
     * @param request
56
     * @param exception
57
     * @return
58
     */
59
    @ExceptionHandler(value = MethodArgumentNotValidException.class) //400
60
    @ResponseBody
61
    public RestResultWrapper methodArgumentValidationHandler(HttpServletRequest request, MethodArgumentNotValidException exception){
62
        logger.info("异常:" + request.getRequestURI(), exception);
63
        logger.info("请求参数错误！{}",getExceptionDetail(exception),"参数数据："+showParams(request));
64
        RestResultWrapper<String> restResultWrapper = new RestResultWrapper();
65
        restResultWrapper.setCode(HttpStatus.BAD_REQUEST.value());
66
        if (exception.getBindingResult() != null && !CollectionUtils.isEmpty(exception.getBindingResult().getAllErrors())) {
67
            restResultWrapper.setMessage(exception.getBindingResult().getAllErrors().get(0).getDefaultMessage());
68
        } else {
69
            restResultWrapper.setMessage(exception.getMessage());
70
        }
71
        return restResultWrapper;
72
    }
73
 
74
    /**
75
     * 绑定异常
76
     * @param request
77
     * @param pe
78
     * @return
79
     */
80
    @ExceptionHandler(BindException.class)
81
    @ResponseBody
82
    public RestResultWrapper bindException(HttpServletRequest request, BindException pe) {
83
        logger.error("异常:" + request.getRequestURI(), pe);
84
        RestResultWrapper<String> restResultWrapper = new RestResultWrapper();
85
        Map map=new HashMap();
86
        if(pe.getBindingResult()!=null){
87
            List<ObjectError> allErrors = pe.getBindingResult().getAllErrors();
88
            allErrors.stream().filter(Objects::nonNull).forEach(objectError -> {
89
                map.put("请求路径："+request.getRequestURI()+"--请求参数："+(((FieldError) ((FieldError) allErrors.get(0))).getField().toString()),objectError.getDefaultMessage());
90
            });
91
        }
92
        restResultWrapper.setCode(HttpStatus.BAD_REQUEST.value());
93
        restResultWrapper.setMessage("请求参数绑定失败");
94
        restResultWrapper.setResult(map.toString());
95
        return restResultWrapper;
96
    }
97
 
98
 
99
    /**
100
     * 访问接口参数不全
101
     * @param request
102
     * @param pe
103
     * @return
104
     */
105
    @ExceptionHandler(MissingServletRequestParameterException.class)
106
    @ResponseBody
107
    public RestResultWrapper missingServletRequestParameterException(HttpServletRequest request, MissingServletRequestParameterException pe) {
108
        logger.error("异常:" + request.getRequestURI(), pe);
109
        RestResultWrapper<String> restResultWrapper = new RestResultWrapper();
110
        restResultWrapper.setCode(HttpStatus.BAD_REQUEST.value());
111
        restResultWrapper.setMessage("该请求路径："+request.getRequestURI()+"下的请求参数不全："+pe.getMessage());
112
        return restResultWrapper;
113
    }
114
 
115
    /**
116
     * HttpRequestMethodNotSupportedException
117
     * @param request
118
     * @param pe
119
     * @return
120
     */
121
    @ExceptionHandler(HttpRequestMethodNotSupportedException.class)
122
    @ResponseBody
123
    public RestResultWrapper httpRequestMethodNotSupportedException(HttpServletRequest request, HttpRequestMethodNotSupportedException pe) {
124
        logger.error("异常:" + request.getRequestURI(), pe);
125
        RestResultWrapper<String> restResultWrapper = new RestResultWrapper();
126
        restResultWrapper.setCode(HttpStatus.BAD_REQUEST.value());
127
        restResultWrapper.setMessage("请求方式不正确");
128
        return restResultWrapper;
129
    }
130
 
131
 
132
    /**
133
     * 其他异常
134
     * @param request
135
     * @param pe
136
     * @return
137
     */
138
    @ExceptionHandler(Exception.class)
139
    @ResponseBody
140
    public RestResultWrapper otherException(HttpServletRequest request, Exception pe) {
141
        logger.error("异常:" + request.getRequestURI(), pe);
142
        RestResultWrapper<String> restResultWrapper = new RestResultWrapper();
143
        restResultWrapper.setCode(HttpStatus.BAD_REQUEST.value());
144
        restResultWrapper.setMessage(getExceptionDetail(pe));
145
        return restResultWrapper;
146
    }
147
 
148
    /**
149
     * 异常详情
150
     * @param e
151
     * @return
152
     */
153
    private String getExceptionDetail(Exception e) {
154
        StringBuilder stringBuffer = new StringBuilder(e.toString() + "\n");
155
        StackTraceElement[] messages = e.getStackTrace();
156
        Arrays.stream(messages).filter(Objects::nonNull).forEach(stackTraceElement -> {
157
            stringBuffer.append(stackTraceElement.toString() + "\n");
158
        });
159
        return stringBuffer.toString();
160
    }
161
 
162
    /**
163
     * 请求参数
164
     * @param request
165
     * @return
166
     */
167
    public  String showParams(HttpServletRequest request) {
168
        Map<String,Object> map = new HashMap<String,Object>();
169
        StringBuilder stringBuilder=new StringBuilder();
170
        Enumeration paramNames = request.getParameterNames();
171
        stringBuilder.append("----------------参数开始-------------------");
172
        stringBuilder.append(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()));
173
        if(Objects.nonNull(paramNames)){
174
            while (paramNames.hasMoreElements()) {
175
                String paramName = (String) paramNames.nextElement();
176
                String[] paramValues = request.getParameterValues(paramName);
177
                if (paramValues.length >0) {
178
                    String paramValue = paramValues[0];
179
                    if (paramValue.length() != 0) {
180
                        stringBuilder.append("参数名:").append(paramName).append("参数值:").append(paramValue);
181
                    }
182
                }
183
            }
184
        }
185
        stringBuilder.append("----------------参数结束-------------------");
186
        return stringBuilder.toString();
187
    }
188
 
189
 
190
}

  验证请求参数还可以通过自定义注解：

如：

手机号码：

1
@ConstraintComposition(CompositionType.OR)
2
//模式
3
@Pattern(regexp = "1[3|4|5|7|8|6][0-9]\\d{8}")
4
@Null
5
@Length(min = 0, max = 16)
6
@Documented
7
@Constraint(validatedBy = {})
8
@Target({ ElementType.METHOD, ElementType.FIELD, ElementType.CONSTRUCTOR, ElementType.PARAMETER })
9
@Retention(RUNTIME)
10
@ReportAsSingleViolation
11
public @interface PhoneVerification {
12
    String message() default "手机号校验错误";
13
 
14
    //分组
15
    Class<?>[] groups() default {};
16
 
17
    //负载
18
    Class<? extends Payload>[] payload() default {};
19
}

身份证：

1
@Target( { METHOD, FIELD, ANNOTATION_TYPE })
2
@Retention(RetentionPolicy.RUNTIME)
3
@Constraint(validatedBy = CardValidate.Validator.class)
4
@Documented
5
public @interface CardValidate {
6
    String message() default "invalid phone number";
7
 
8
    //分组
9
    Class<?>[] groups() default {};
10
 
11
    //负载
12
    Class<? extends Payload>[] payload() default {};
13
 
14
    class Validator implements ConstraintValidator<CardValidate, String> {
15
        @Override
16
        public boolean isValid(String carid, ConstraintValidatorContext arg1){
17
            if(!StringUtils.isEmpty(carid)){
18
                //RegexValidateUtils.checkCard(carid)
19
                //TODO 验证逻辑
20
                return true;
21
            }else{
22
                return true;
23
            }
24
        }
25
    }
26
}

分组校验：https://www.cnkirito.moe/spring-validation/

@Validated和@Valid区别：https://blog.csdn.net/qq_27680317/article/details/79970590

@Validated和@Valid在嵌套验证功能上的区别：

          @Validated：用在方法入参上无法单独提供嵌套验证功能。不能用在成员属性（字段）上，也无法提示框架进行嵌套验证。能配合嵌套验证注解@Valid进行嵌套验证。

         @Valid：用在方法入参上无法单独提供嵌套验证功能。能够用在成员属性（字段）上，提示验证框架进行嵌套验证。能配合嵌套验证注解@Valid进行嵌套验证。

代码参考：https://github.com/timeday/springboot-validateexception